// @/api/detail.js

let socketTask = null;
let aiSummarySocketTask = null; // AI总结专用的WebSocket连接
let isConnected = false;
let isAiSummaryConnected = false; // AI总结连接状态
let hasReceivedHistory = false; // 标记是否已接收历史消息

// 默认配置
const defaultConfig = {
  baseUrl: 'ws://localhost:8006',
  endpoint: '/chat',
  meetId: '',
  username: '',
  headImg: ''
};

// AI总结配置
const aiSummaryConfig = {
  baseUrl: 'ws://localhost:8006',
  endpoint: '/attendee', // 可根据实际后端接口调整
  meetId: ''
};

export function initChatSocket(options) {
  console.log('开始初始化WebSocket连接', options);
  
  if (!options.meetId || !options.username || !options.headImg || !options.onMessage) {
    console.error('初始化失败: 缺少必要参数');
    return null;
  }

  // 保存连接参数
  defaultConfig.meetId = options.meetId;
  defaultConfig.username = options.username;
  defaultConfig.headImg = options.headImg;

  // 先关闭现有连接
  if (socketTask) {
    console.log('关闭旧连接');
    closeChatSocket();
  }

  const config = { ...defaultConfig, ...options };
  const url = `${config.baseUrl}${config.endpoint}/${config.meetId}?username=${encodeURIComponent(config.username)}&headImg=${encodeURIComponent(config.headImg)}`;
  
  console.log('创建新连接', url);
  hasReceivedHistory = false; // 重置历史消息标记

  try {
    socketTask = uni.connectSocket({
      url: url,
      success: () => {
        console.log('连接创建成功');
        // 成功创建连接后，在onOpen事件中设置isConnected
      },
      fail: (err) => {
        console.error('连接创建失败', err);
        socketTask = null;
        isConnected = false;
        if (options.onError) {
          options.onError(err);
        }
      }
    });

    // 设置WebSocket事件监听
    socketTask.onOpen((res) => {
      console.log('WebSocket连接已打开', res);
      isConnected = true;
      hasReceivedHistory = false;
      if (options.onOpen) {
        options.onOpen(res);
      }
    });

    socketTask.onMessage((res) => {
      console.log('收到WebSocket消息', typeof res.data, res.data.substring(0, 100));
      try {
        let data;
        try {
          // 首先尝试解析JSON格式
          data = JSON.parse(res.data);
          
          if (data.error) {
            console.error('服务器错误', data.error);
            return;
          }

          if (data.chatMessage) {
            console.log('收到历史消息');
            options.onMessage({
              type: 'history',
              data: data.chatMessage
            });
          } else if (data.content) {
            console.log('收到实时消息', data);
            options.onMessage({
              type: 'message',
              data: data
            });
          } else {
            console.warn('未知消息格式', data);
            // 尝试检查数据是否为自定义格式
            if (data && typeof data === 'object') {
              // 如果对象中包含了可能的消息字段，尝试作为消息处理
              if (data.username || data.headImg || data.time) {
                console.log('识别为可能的消息格式', data);
                options.onMessage({
                  type: 'message',
                  data: data
                });
                return;
              }
            }
          }
        } catch (e) {
          // console.error('JSON解析失败，尝试解析Java对象格式', e);
          // 解析Java对象格式 {key='value'} 的字符串
          const messageStr = res.data.replace(/^\{|\}$/g, '');
          data = {};
          messageStr.split(',').forEach(item => {
            const [key, value] = item.split('=');
            if (key && value) {
              const trimmedKey = key.trim();
              // 处理content字段中的JSON字符串
              let trimmedValue = value.replace(/^'|'$/g, '');
              if (trimmedKey === 'content' && trimmedValue.startsWith('{')) {
                try {
                  // 解析content中的JSON字符串
                  const contentObj = JSON.parse(trimmedValue);
                  trimmedValue = contentObj.content || trimmedValue;
                } catch (e) {
                  console.warn('解析content JSON失败:', e);
                }
              }
              data[trimmedKey] = trimmedValue;
            }
          });

          // 验证解析后的数据是否包含必要字段
          if (data.content && data.username && data.time) {
            console.log('成功解析Java对象格式消息', data);
            options.onMessage({
              type: 'message',
              data: {
                content: data.content,
                username: data.username,
                headImg: data.headImg || '/static/logo.png',
                time: data.time
              }
            });
          } else {
            console.warn('Java对象格式消息缺少必要字段', data);
            // 最后尝试直接传递原始消息
            options.onMessage({
              type: 'message',
              data: {
                content: res.data,
                username: '系统消息',
                headImg: '/static/logo.png',
                time: Date.now().toString()
              }
            });
          }
        }
      } catch (e) {
        console.error('消息处理异常', e, res.data);
        // 发生异常时，尝试将原始消息作为文本显示
        try {
          options.onMessage({
            type: 'message',
            data: {
              content: String(res.data),
              username: '系统消息',
              headImg: '/static/logo.png',
              time: Date.now().toString()
            }
          });
        } catch (finalError) {
          console.error('无法处理消息', finalError);
        }
      }
    });

    socketTask.onClose((res) => {
      console.log('WebSocket连接已关闭', res);
      isConnected = false;
      socketTask = null;
      
      if (options.onClose) {
        options.onClose(res);
      }
    });

    socketTask.onError((err) => {
      console.error('WebSocket连接错误', err);
      isConnected = false;
      socketTask = null;
      
      if (options.onError) {
        options.onError(err);
      }
    });

    return socketTask;
  } catch (error) {
    console.error('创建WebSocket连接异常', error);
    socketTask = null;
    isConnected = false;
    if (options.onError) {
      options.onError(error);
    }
    return null;
  }
}

/**
 * 发送聊天消息
 * @param {string|Object} content - 消息内容（字符串或对象）
 */
export function sendChatMessage(content) {
  console.log('准备发送消息', content);
  
  return new Promise((resolve, reject) => {
    if (!isConnected || !socketTask) {
      console.error('WebSocket未连接，无法发送消息');
      resolve(false);
      return;
    }

    try {
      // 构建消息对象
      const messageData = {
        content: content,
        username: defaultConfig.username,
        headImg: defaultConfig.headImg,
        time: Date.now().toString()
      };

      console.log('发送消息对象', messageData);
      
      // 将消息对象转为JSON字符串发送
      socketTask.send({
        data: JSON.stringify(messageData),
        success: () => {
          console.log('消息发送成功');
          resolve(true);
        },
        fail: (err) => {
          console.error('消息发送失败', err);
          resolve(false);
        }
      });
    } catch (error) {
      console.error('发送消息异常', error);
      resolve(false);
    }
  });
}

/**
 * 主动关闭WebSocket连接
 */
export function closeChatSocket() {
  if (socketTask) {
    console.log('开始主动关闭WebSocket连接');
    try {
      socketTask.close({
        success: () => {
          console.log('WebSocket连接已主动关闭');
          isConnected = false;
          socketTask = null;
        },
        fail: (err) => {
          console.error('主动关闭WebSocket连接失败', err);
          isConnected = false;
          socketTask = null;
        }
      });
    } catch (error) {
      console.error('主动关闭WebSocket连接异常', error);
      isConnected = false;
      socketTask = null;
    }
  }
}

/**
 * 检查WebSocket连接状态
 * @returns {boolean} 是否已连接
 */
export function isChatSocketConnected() {
  return isConnected;
}

/**
 * 初始化AI总结WebSocket连接
 * @param {Object} options - 连接配置
 * @param {string} options.meetId - 必须，会议ID
 * @param {function} options.onMessage - 必须，收到消息回调
 * @param {function} [options.onOpen] - 可选，连接成功回调
 * @param {function} [options.onClose] - 可选，连接关闭回调
 * @param {function} [options.onError] - 可选，连接错误回调
 */
export function initAiSummarySocket(options) {
  console.log('开始初始化AI总结WebSocket连接', options);
  
  if (!options.meetId || !options.onMessage) {
    console.error('AI总结初始化失败: 缺少必要参数');
    return null;
  }

  // 保存连接参数
  aiSummaryConfig.meetId = options.meetId;

  // 先关闭现有连接
  if (aiSummarySocketTask) {
    console.log('关闭旧AI总结连接');
    closeAiSummarySocket();
  }

  const config = { ...aiSummaryConfig, ...options };
  const url = `${config.baseUrl}${config.endpoint}/${config.meetId}`;
  
  console.log('创建新AI总结连接', url);

  try {
    aiSummarySocketTask = uni.connectSocket({
      url: url,
      success: () => {
        console.log('AI总结连接创建成功');
      },
      fail: (err) => {
        console.error('AI总结连接创建失败', err);
        aiSummarySocketTask = null;
        isAiSummaryConnected = false;
        if (options.onError) {
          options.onError(err);
        }
      }
    });

    // 设置WebSocket事件监听
    aiSummarySocketTask.onOpen((res) => {
      console.log('AI总结WebSocket连接已打开', res);
      isAiSummaryConnected = true;
      if (options.onOpen) {
        options.onOpen(res);
      }
    });

    aiSummarySocketTask.onMessage((res) => {
      console.log('收到AI总结WebSocket消息', res.data);
      try {
        let data;
        try {
          // 首先尝试解析JSON格式
          data = JSON.parse(res.data);
          
          if (data.error) {
            console.error('AI总结服务器错误', data.error);
            return;
          }

          // 处理AI总结消息，传递给onMessage回调
          options.onMessage({
            type: 'attendee',
            data: data
          });
        } catch (e) {
          console.error('AI总结JSON解析失败', e);
          // 如果JSON解析失败，尝试直接传递原始消息
          options.onMessage({
            type: 'attendee',
            data: {
              content: res.data,
              time: Date.now().toString()
            }
          });
        }
      } catch (e) {
        console.error('AI总结消息处理异常', e, res.data);
      }
    });

    aiSummarySocketTask.onClose((res) => {
      console.log('AI总结WebSocket连接已关闭', res);
      isAiSummaryConnected = false;
      aiSummarySocketTask = null;
      
      if (options.onClose) {
        options.onClose(res);
      }
    });

    aiSummarySocketTask.onError((err) => {
      console.error('AI总结WebSocket连接错误', err);
      isAiSummaryConnected = false;
      aiSummarySocketTask = null;
      
      if (options.onError) {
        options.onError(err);
      }
    });

    return aiSummarySocketTask;
  } catch (error) {
    console.error('创建AI总结WebSocket连接异常', error);
    aiSummarySocketTask = null;
    isAiSummaryConnected = false;
    if (options.onError) {
      options.onError(error);
    }
    return null;
  }
}

/**
 * 主动关闭AI总结WebSocket连接
 */
export function closeAiSummarySocket() {
  if (aiSummarySocketTask) {
    console.log('开始关闭AI总结WebSocket连接');
    try {
      aiSummarySocketTask.close({
        success: () => {
          console.log('AI总结WebSocket连接已关闭');
          isAiSummaryConnected = false;
          aiSummarySocketTask = null;
        },
        fail: (err) => {
          console.error('关闭AI总结WebSocket连接失败', err);
          isAiSummaryConnected = false;
          aiSummarySocketTask = null;
        }
      });
    } catch (error) {
      console.error('关闭AI总结WebSocket连接异常', error);
      isAiSummaryConnected = false;
      aiSummarySocketTask = null;
    }
  }
}

/**
 * 检查AI总结WebSocket连接状态
 * @returns {boolean} 是否已连接
 */
export function isAiSummarySocketConnected() {
  return isAiSummaryConnected;
}
